Guide d'inférence LLM

L'API d'inférence LLM vous permet d'exécuter des grands modèles de langage (LLM) entièrement sur l'appareil, que vous pouvez utiliser pour effectuer un large éventail de tâches, telles que la génération de texte, la récupération d'informations sous forme de langage naturel et le résumé de documents. La tâche est compatible avec plusieurs grands modèles de langage de texte à texte, ce qui vous permet d'appliquer les derniers modèles d'IA générative sur l'appareil à vos applications et produits.

Essayez !arrow_forward

La tâche est compatible avec de nombreux LLM. Les modèles hébergés sur la page de la communauté LITERAT sont disponibles dans un format compatible avec MediaPipe et ne nécessitent aucune étape de conversion ou de compilation supplémentaire.

Vous pouvez utiliser AI Edge Torch pour exporter des modèles PyTorch vers des modèles LiteRT (tflite) multisignature, qui sont regroupés avec des paramètres de tokenizer pour créer des bundles de tâches. Les modèles convertis avec AI Edge Torch sont compatibles avec l'API d'inférence LLM et peuvent s'exécuter sur le backend du processeur, ce qui les rend adaptés aux applications Android et iOS.

Premiers pas

Pour commencer à utiliser cette tâche, suivez l'un de ces guides d'implémentation pour votre plate-forme cible. Ces guides spécifiques à la plate-forme vous expliquent comment implémenter cette tâche de manière basique, avec des exemples de code qui utilisent un modèle disponible et les options de configuration recommandées:

• Web:

  • Guide
  • Exemple de code

• Android :

  • Guide
  • Exemple de code

• iOS

  • Guide
  • Exemple de code

Détails de la tâche

Cette section décrit les fonctionnalités, les entrées, les sorties et les options de configuration de cette tâche.

Fonctionnalités

L'API LLM Inference contient les principales fonctionnalités suivantes:

1. Génération de texte à partir de texte : génère du texte à partir d'une requête textuelle.
2. Sélection de LLM : appliquez plusieurs modèles pour adapter l'application à vos cas d'utilisation spécifiques. Vous pouvez également réentraîner le modèle et appliquer des poids personnalisés.
3. Compatibilité avec LoRA : étendez et personnalisez les fonctionnalités du LLM avec le modèle LoRA en l'entraînant sur l'ensemble de données complet ou en utilisant des modèles LoRA prédéfinis préparés par la communauté Open Source (non compatibles avec les modèles convertis avec l'API générative Torch Edge AI).

Options de configuration

Cette tâche propose les options de configuration suivantes:

Modèles

L'API d'inférence LLM est compatible avec de nombreux grands modèles de langage de texte à texte, y compris la prise en charge intégrée de plusieurs modèles optimisés pour s'exécuter sur les navigateurs et les appareils mobiles. Ces modèles légers peuvent être utilisés pour exécuter des inférences entièrement sur l'appareil.

Avant d'initialiser l'API d'inférence LLM, téléchargez un modèle et stockez le fichier dans le répertoire de votre projet. Vous pouvez utiliser un modèle préconverti à partir du dépôt HuggingFace de la communauté LITERAT, ou convertir un modèle dans un format compatible avec MediaPipe à l'aide du convertisseur génératif Torch d'AI Edge.

Si vous ne disposez pas encore d'un LLM à utiliser avec l'API d'inférence LLM, commencez avec l'un des modèles suivants.

Gemma-3 1B

Gemma-3 1B est le dernier modèle de la famille Gemma, une gamme de modèles ouverts, légers et de pointe conçus à partir des mêmes recherches et technologies que celles utilisées pour créer les modèles Gemini. Le modèle contient 1 milliard de paramètres et de pondérations ouvertes. La variante 1B est le modèle le plus léger de la famille Gemma, ce qui la rend idéale pour de nombreux cas d'utilisation sur l'appareil.

Télécharger Gemma-3 1B

Le modèle Gemma-3 1B de HuggingFace est disponible au format .task et prêt à l'emploi avec l'API d'inférence LLM pour les applications Android et Web.

Lorsque vous exécutez Gemma-3 1B avec l'API d'inférence LLM, configurez les options suivantes en conséquence:

• preferredBackend: utilisez cette option pour choisir entre un backend CPU ou GPU. Cette option n'est disponible que pour Android.
• supportedLoraRanks: L'API d'inférence LLM ne peut pas être configurée pour prendre en charge l'adaptation de rang faible (LoRA) avec le modèle Gemma-3 1B. N'utilisez pas les options supportedLoraRanks ou loraRanks.
• maxTokens: la valeur de maxTokens doit correspondre à la taille de contexte intégrée au modèle. On peut également l'appeler cache clé-valeur (KV) ou longueur de contexte.
• numResponses: doit toujours être défini sur 1. Cette option n'est disponible que pour le Web.

Lorsque vous exécutez Gemma-3 1B sur des applications Web, l'initialisation peut entraîner un blocage prolongé dans le thread en cours. Dans la mesure du possible, exécutez toujours le modèle à partir d'un thread de travail.

Gemma-2 2B

Gemma-2 2B est une variante 2B de Gemma-2 et fonctionne sur toutes les plates-formes.

Télécharger Gemma-2 2B

Le modèle contient 2 milliards de paramètres et de pondérations ouvertes. Gemma-2 2B est réputé pour ses capacités de raisonnement de pointe pour les modèles de sa catégorie.

Conversion de modèles PyTorch

Les modèles génératifs PyTorch peuvent être convertis en format compatible avec MediaPipe avec l'API générative AI Edge Torch. Vous pouvez utiliser l'API pour convertir des modèles PyTorch en modèles LiteRT (TensorFlow Lite) à signature multiple. Pour en savoir plus sur la cartographie et l'exportation de modèles, consultez la page GitHub d'AI Edge Torch.

Pour convertir un modèle PyTorch avec l'API générative Torch d'IA Edge, procédez comme suit:

1. Téléchargez les points de contrôle du modèle PyTorch.
2. Utilisez l'API générative Torch AI Edge pour créer, convertir et quantizer le modèle dans un format de fichier compatible avec MediaPipe (.tflite).
3. Créez un bundle de tâches (.task) à partir du fichier tflite et du tokenizer du modèle.

Le convertisseur génératif Torch ne convertit que pour le processeur et nécessite une machine Linux avec au moins 64 Go de RAM.

Pour créer un groupe de tâches, utilisez le script de regroupement pour créer un groupe de tâches. Le processus de regroupement empaquette le modèle mappé avec des métadonnées supplémentaires (par exemple, Paramètres du tokenizer) nécessaires pour exécuter l'inférence de bout en bout.

Le processus de regroupement de modèles nécessite le package PyPI MediaPipe. Le script de conversion est disponible dans tous les packages MediaPipe après 0.10.14.

Installez et importez les dépendances avec la commande suivante:

$ python3 -m pip install mediapipe

Utilisez la bibliothèque genai.bundler pour regrouper le modèle:

import mediapipe as mp
from mediapipe.tasks.python.genai import bundler

config = bundler.BundleConfig(
    tflite_model=TFLITE_MODEL,
    tokenizer_model=TOKENIZER_MODEL,
    start_token=START_TOKEN,
    stop_tokens=STOP_TOKENS,
    output_filename=OUTPUT_FILENAME,
    enable_bytes_to_unicode_mapping=ENABLE_BYTES_TO_UNICODE_MAPPING,
)
bundler.create_bundle(config)

Personnalisation LoRA

La prise en charge de LoRA par l'API d'inférence LLM fonctionne pour toutes les variantes de Gemma et les modèles Phi-2 pour le backend GPU, les poids LoRA ne s'appliquant qu'aux couches d'attention. Cette implémentation initiale sert d'API expérimentale pour les futurs développements. Nous prévoyons de prendre en charge davantage de modèles et différents types de calques dans les prochaines mises à jour.

Préparer des modèles LoRA

Suivez les instructions sur HuggingFace pour entraîner un modèle LoRA affiné sur votre propre ensemble de données avec les types de modèles compatibles, Gemma ou Phi-2. Les modèles Gemma-2 2B, Gemma 2B et Phi-2 sont tous deux disponibles sur Hugging Face au format safetensors. Étant donné que l'API d'inférence LLM n'est compatible qu'avec LORA sur les couches d'attention, ne spécifiez que les couches d'attention lors de la création de LoraConfig comme suit:

# For Gemma
from peft import LoraConfig
config = LoraConfig(
    r=LORA_RANK,
    target_modules=["q_proj", "v_proj", "k_proj", "o_proj"],
)

# For Phi-2
config = LoraConfig(
    r=LORA_RANK,
    target_modules=["q_proj", "v_proj", "k_proj", "dense"],
)

Pour les tests, des modèles LoRA affinés accessibles au public qui correspondent à l'API d'inférence LLM sont disponibles sur HuggingFace. Par exemple, monsterapi/gemma-2b-lora-maths-orca-200k pour Gemma-2B et lole25/phi-2-sft-ultrachat-lora pour Phi-2.

Après avoir entraîné le modèle sur l'ensemble de données préparé et enregistré le modèle, vous obtenez un fichier adapter_model.safetensors contenant les poids du modèle LoRA affinés. Le fichier safetensors est le point de contrôle LoRA utilisé lors de la conversion du modèle.

L'étape suivante consiste à convertir les poids du modèle en Flatbuffer TensorFlow Lite à l'aide du package Python MediaPipe. ConversionConfig doit spécifier les options de modèle de base ainsi que les options LoRA supplémentaires. Notez que, comme l'API n'est compatible qu'avec l'inférence LoRA avec GPU, le backend doit être défini sur 'gpu'.

import mediapipe as mp
from mediapipe.tasks.python.genai import converter

config = converter.ConversionConfig(
  # Other params related to base model
  ...
  # Must use gpu backend for LoRA conversion
  backend='gpu',
  # LoRA related params
  lora_ckpt=LORA_CKPT,
  lora_rank=LORA_RANK,
  lora_output_tflite_file=LORA_OUTPUT_TFLITE_FILE,
)

converter.convert_checkpoint(config)

Le convertisseur génère deux fichiers FlatBuffer TFLite, l'un pour le modèle de base et l'autre pour le modèle LoRA.

Inférence de modèle LoRA

L'API d'inférence LLM pour le Web, Android et iOS est mise à jour pour prendre en charge l'inférence de modèle LoRA.

// Set the configuration options for the LLM Inference task
val options = LlmInferenceOptions.builder()
        .setModelPath('<path to base model>')
        .setMaxTokens(1000)
        .setTopK(40)
        .setTemperature(0.8)
        .setRandomSeed(101)
        .setLoraPath('<path to LoRA model>')
        .build()

// Create an instance of the LLM Inference task
llmInference = LlmInference.createFromOptions(context, options)

Pour exécuter l'inférence LLM avec LoRA, utilisez les mêmes méthodes generateResponse() ou generateResponseAsync() que le modèle de base.